/*
 * Copyright © 2016-2018 European Support Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation;

import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_NESTED_RESOURCE_PROPERTY_NOT_DEFINED;
import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_UNSUPPORTED_CAPABILITY_CONNECTION;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Predicate;
import org.onap.sdc.tosca.datatypes.model.CapabilityDefinition;
import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
import org.onap.sdc.tosca.datatypes.model.NodeType;
import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
import org.onap.sdc.tosca.datatypes.model.RequirementDefinition;
import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
import org.openecomp.sdc.heat.datatypes.manifest.FileData;
import org.openecomp.sdc.heat.datatypes.model.Resource;
import org.openecomp.sdc.tosca.services.DataModelUtil;
import org.openecomp.sdc.tosca.services.ToscaConstants;
import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslatedHeatResource;
import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil;
import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
import org.openecomp.sdc.translator.services.heattotosca.ResourceTranslationFactory;

public abstract class ResourceConnectionUsingCapabilityHelper extends BaseResourceConnection<CapabilityDefinition> {

    ResourceConnectionUsingCapabilityHelper(ResourceTranslationBase resourceTranslationBase, TranslateTo translateTo, FileData nestedFileData,
                                            NodeTemplate substitutionNodeTemplate, NodeType nodeType) {
        super(resourceTranslationBase, translateTo, nestedFileData, substitutionNodeTemplate, nodeType);
    }

    abstract Map.Entry<String, RequirementDefinition> createRequirementDefinition(String capabilityKey);

    @Override
    String getMappedNodeTranslatedResourceId(ServiceTemplate nestedServiceTemplate, Map.Entry<String, CapabilityDefinition> connectionPointEntry) {
        List<String> substitutionMapping = nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getCapabilities()
            .get(connectionPointEntry.getKey());
        return substitutionMapping.get(0);
    }

    @Override
    Map.Entry<String, CapabilityDefinition> getMappedConnectionPointEntry(ServiceTemplate nestedServiceTemplate,
                                                                          Map.Entry<String, CapabilityDefinition> connectionPointEntry) {
        List<String> substitutionMapping = nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getCapabilities()
            .get(connectionPointEntry.getKey());
        String mappedNodeTranslatedId = substitutionMapping.get(0);
        String mappedCapabilityId = substitutionMapping.get(1);
        NodeTemplate mappedNodeTemplate = nestedServiceTemplate.getTopology_template().getNode_templates().get(mappedNodeTranslatedId);
        NodeType substituteNodeType = translateTo.getContext().getGlobalSubstitutionServiceTemplate().getNode_types()
            .get(mappedNodeTemplate.getType());
        Optional<CapabilityDefinition> capabilityDefinition = DataModelUtil.getCapabilityDefinition(substituteNodeType, mappedCapabilityId);
        return new Map.Entry<String, CapabilityDefinition>() {
            @Override
            public String getKey() {
                return mappedCapabilityId;
            }

            @Override
            public CapabilityDefinition getValue() {
                return capabilityDefinition.orElse(null);
            }

            @Override
            public CapabilityDefinition setValue(CapabilityDefinition value) {
                return null;
            }
        };
    }

    @Override
    protected List<Map<String, CapabilityDefinition>> getAllConnectionPoints() {
        List<Map<String, CapabilityDefinition>> exposedRequirementsList = new ArrayList<>();
        List<Predicate<CapabilityDefinition>> predicates = getPredicatesListForConnectionPoints();
        Map<String, CapabilityDefinition> capabilities = this.nodeType.getCapabilities();
        if (capabilities == null) {
            return exposedRequirementsList;
        }
        capabilities.entrySet().stream().filter(entry -> predicates.stream().anyMatch(p -> p.test(entry.getValue()))).forEach(entry -> {
            Map<String, CapabilityDefinition> exposedRequirementsMap = new HashMap<>();
            exposedRequirementsMap.put(entry.getKey(), entry.getValue());
            exposedRequirementsList.add(exposedRequirementsMap);
        });
        return exposedRequirementsList;
    }

    void addRequirementToConnectResource(Map.Entry<String, CapabilityDefinition> connectionPointEntry, List<String> supportedSourceNodeTypes,
                                         String paramName) {
        Object paramValue = translateTo.getResource().getProperties().get(paramName);
        if (paramValue == null) {
            logger.warn(LOG_NESTED_RESOURCE_PROPERTY_NOT_DEFINED, paramName, translateTo.getResourceId(), connectionPointEntry.getKey(),
                ToscaConstants.CAPABILITY);
            return;
        }
        Map.Entry<String, RequirementDefinition> requirementDefinition = createRequirementDefinition(connectionPointEntry.getKey());
        Optional<String> sourceResourceId = getConnectionResourceUsingGetResourceFunc(connectionPointEntry, paramName, paramValue,
            supportedSourceNodeTypes);
        if (sourceResourceId.isPresent()) {
            Resource sourceResource = HeatToToscaUtil
                .getResource(translateTo.getHeatOrchestrationTemplate(), sourceResourceId.get(), translateTo.getHeatFileName());
            Optional<String> translatedSourceNodeId = ResourceTranslationFactory.getInstance(sourceResource)
                .translateResource(translateTo.getHeatFileName(), translateTo.getServiceTemplate(), translateTo.getHeatOrchestrationTemplate(),
                    sourceResource, sourceResourceId.get(), translateTo.getContext());
            if (translatedSourceNodeId.isPresent()) {
                NodeTemplate sourceNodeTemplate = DataModelUtil.getNodeTemplate(translateTo.getServiceTemplate(), translatedSourceNodeId.get());
                RequirementAssignment requirementAssignment = createRequirementAssignment(requirementDefinition, translateTo.getTranslatedId(),
                    sourceNodeTemplate);
                ConsolidationDataUtil.updateNodesConnectedData(translateTo, translateTo.getResourceId(), translateTo.getResource(), sourceResource,
                    translatedSourceNodeId.get(), requirementDefinition.getKey(), requirementAssignment);
            } else {
                logger.warn(LOG_UNSUPPORTED_CAPABILITY_CONNECTION, sourceResource.getType(), connectionPointEntry.getKey(),
                    connectionPointEntry.getValue().getType());
            }
        } else {
            Optional<TranslatedHeatResource> sharedSourceTranslatedHeatResource = getConnectionTranslatedHeatResourceUsingGetParamFunc(
                connectionPointEntry, paramName, supportedSourceNodeTypes);
            if (sharedSourceTranslatedHeatResource.isPresent()) {
                NodeTemplate sharedSourceNodeTemplate = DataModelUtil
                    .getNodeTemplate(translateTo.getServiceTemplate(), sharedSourceTranslatedHeatResource.get().getTranslatedId());
                RequirementAssignment requirementAssignment = createRequirementAssignment(requirementDefinition, translateTo.getTranslatedId(),
                    sharedSourceNodeTemplate);
                ConsolidationDataUtil.updateNodesConnectedData(translateTo, translateTo.getResourceId(), translateTo.getResource(),
                    sharedSourceTranslatedHeatResource.get().getHeatResource(), sharedSourceTranslatedHeatResource.get().getTranslatedId(),
                    requirementDefinition.getKey(), requirementAssignment);
            }
        }
    }
}
